import { defineStore } from 'pinia';
import { ref, computed } from 'vue';
import { v4 as uuidv4 } from 'uuid';
import { sendChatMessageStream } from '../api/chat';

/**
 * 聊天存储模块
 * 负责管理聊天会话、消息历史和API交互
 */
export const useChatStore = defineStore('chat', () => {
    // ===== 状态定义 =====
    const state = {
        // 聊天消息历史
        messageHistory: ref([]),
        // 加载状态
        loading: ref(false),
        // 当前活跃的请求
        activeRequest: ref(null),
        // 当前聊天会话ID
        currentChatId: ref(''),
        // 所有聊天会话
        chatSessions: ref([]),
        // 会话消息映射表 - 存储每个会话的消息
        sessionMessages: ref({}),
    };

    // ===== 计算属性 =====
    const getters = {
        // 获取当前会话
        currentSession: computed(() => {
            return state.chatSessions.value.find(session =>
                session.id === state.currentChatId.value
            ) || null;
        }),
    };

    // ===== 持久化相关 =====
    const persistence = {
        /**
         * 从localStorage加载会话数据
         */
        loadFromStorage() {
            try {
                const savedSessions = localStorage.getItem('chat_sessions');
                const savedMessages = localStorage.getItem('session_messages');

                if (savedSessions) {
                    state.chatSessions.value = JSON.parse(savedSessions);
                }

                if (savedMessages) {
                    state.sessionMessages.value = JSON.parse(savedMessages);
                }

                return true;
            } catch (error) {
                console.error('加载会话数据失败:', error);
                return false;
            }
        },

        /**
         * 保存会话数据到localStorage
         */
        saveToStorage() {
            try {
                localStorage.setItem('chat_sessions', JSON.stringify(state.chatSessions.value));
                localStorage.setItem('session_messages', JSON.stringify(state.sessionMessages.value));
                return true;
            } catch (error) {
                console.error('保存会话数据失败:', error);
                return false;
            }
        },
    };

    // ===== 会话管理 =====
    const sessionManager = {
        /**
         * 初始化Store
         */
        initStore() {
            const loadSuccess = persistence.loadFromStorage();

            // 如果没有会话或加载失败，创建一个新会话
            if (!loadSuccess || state.chatSessions.value.length === 0) {
                this.createNewChatSession();
            } else {
                // 使用最近的会话ID
                state.currentChatId.value = state.chatSessions.value[0].id;
                // 加载对应会话的消息
                this.loadSessionMessages(state.currentChatId.value);
            }
        },

        /**
         * 加载指定会话的消息
         * @param {string} sessionId 会话ID
         */
        loadSessionMessages(sessionId) {
            // 如果会话存在消息，加载它
            if (state.sessionMessages.value[sessionId]) {
                state.messageHistory.value = state.sessionMessages.value[sessionId];
            } else {
                state.messageHistory.value = [];
            }
        },

        /**
         * 保存当前会话的消息
         */
        saveCurrentSessionMessages() {
            if (!state.currentChatId.value) return;

            state.sessionMessages.value[state.currentChatId.value] = [...state.messageHistory.value];

            // 更新会话标题 - 使用第一条用户消息的内容
            this.updateSessionTitle();

            persistence.saveToStorage();
        },

        /**
         * 更新当前会话的标题
         */
        updateSessionTitle() {
            const firstUserMessage = state.messageHistory.value.find(msg => msg.role === 'user');
            if (!firstUserMessage) return;

            const sessionIndex = state.chatSessions.value.findIndex(
                s => s.id === state.currentChatId.value
            );

            if (sessionIndex !== -1) {
                const maxTitleLength = 20;
                state.chatSessions.value[sessionIndex].title =
                    firstUserMessage.content.length > maxTitleLength
                        ? firstUserMessage.content.substring(0, maxTitleLength) + '...'
                        : firstUserMessage.content;

                // 更新时间戳
                state.chatSessions.value[sessionIndex].updatedAt = new Date().toISOString();
            }
        },

        /**
         * 切换聊天会话
         * @param {string} sessionId 会话ID
         */
        switchChatSession(sessionId) {
            // 先保存当前会话的消息
            this.saveCurrentSessionMessages();

            // 切换会话ID
            state.currentChatId.value = sessionId;

            // 加载新会话的消息
            this.loadSessionMessages(sessionId);

            // 将当前会话移到列表最前面
            this.moveSessionToTop(sessionId);
        },

        /**
         * 将指定会话移到列表顶部
         * @param {string} sessionId 会话ID
         */
        moveSessionToTop(sessionId) {
            const sessionIndex = state.chatSessions.value.findIndex(s => s.id === sessionId);
            if (sessionIndex > 0) {
                const session = state.chatSessions.value.splice(sessionIndex, 1)[0];
                state.chatSessions.value.unshift(session);
                persistence.saveToStorage();
            }
        },

        /**
         * 创建新的聊天会话
         * @returns {string} 新创建的聊天ID
         */
        createNewChatSession() {
            // 取消所有进行中的请求
            messageHandler.cancelActiveRequest();

            // 保存当前会话的消息
            this.saveCurrentSessionMessages();

            // 生成新的聊天ID
            const newChatId = uuidv4();
            state.currentChatId.value = newChatId;

            // 创建新会话
            const newSession = {
                id: newChatId,
                title: '新对话',
                createdAt: new Date().toISOString(),
                updatedAt: new Date().toISOString()
            };

            // 将新会话添加到会话列表的最前面
            state.chatSessions.value.unshift(newSession);

            // 清空当前消息历史
            state.messageHistory.value = [];

            // 保存会话数据
            persistence.saveToStorage();

            return newChatId;
        },

        /**
         * 删除聊天会话
         * @param {string} sessionId 要删除的会话ID
         */
        deleteChatSession(sessionId) {
            // 如果删除的是当前会话，则需要切换到其他会话
            const isCurrentSession = sessionId === state.currentChatId.value;

            // 从会话列表中删除
            const sessionIndex = state.chatSessions.value.findIndex(s => s.id === sessionId);
            if (sessionIndex !== -1) {
                state.chatSessions.value.splice(sessionIndex, 1);
            }

            // 删除对应的消息记录
            if (state.sessionMessages.value[sessionId]) {
                delete state.sessionMessages.value[sessionId];
            }

            // 如果删除的是当前会话，处理会话切换
            if (isCurrentSession) {
                this.handleAfterCurrentSessionDelete();
            }

            // 保存会话数据
            persistence.saveToStorage();
        },

        /**
         * 当前会话被删除后的处理逻辑
         */
        handleAfterCurrentSessionDelete() {
            if (state.chatSessions.value.length > 0) {
                this.switchChatSession(state.chatSessions.value[0].id);
            } else {
                // 如果没有会话了，创建一个新的
                this.createNewChatSession();
            }
        },

        /**
         * 清空当前会话的聊天历史
         */
        clearHistory() {
            // 取消所有进行中的请求
            messageHandler.cancelActiveRequest();

            // 清空当前消息历史
            state.messageHistory.value = [];

            // 保存当前会话的消息(空消息)
            this.saveCurrentSessionMessages();
        },
    };

    // ===== 消息处理 =====
    const messageHandler = {
        /**
         * 确保消息有正确的角色设置
         * @returns {boolean} 是否进行了修正
         */
        ensureMessageRoles() {
            // 检查消息历史中的每条消息，确保role字段正确设置
            let needsCorrection = false;

            state.messageHistory.value.forEach((msg, index) => {
                // 根据消息的索引位置推断角色（假设消息交替出现）
                const expectedRole = index % 2 === 0 ? 'user' : 'assistant';

                // 如果角色不正确或未设置，进行修正
                if (!msg.role || msg.role !== expectedRole) {
                    console.log(`修正消息角色: ID=${msg.id}, 原角色=${msg.role}, 新角色=${expectedRole}`);
                    state.messageHistory.value[index] = {
                        ...msg,
                        role: expectedRole
                    };
                    needsCorrection = true;
                }
            });

            // 如果进行了修正，保存更新后的消息
            if (needsCorrection) {
                sessionManager.saveCurrentSessionMessages();
            }

            return needsCorrection;
        },

        /**
         * 添加用户消息到历史
         * @param {string} message 用户消息
         * @returns {string} 消息ID
         */
        addUserMessage(message) {
            const userMessageId = uuidv4();
            state.messageHistory.value.push({
                id: userMessageId,
                role: 'user',
                content: message,
                timestamp: new Date().toISOString(),
            });
            return userMessageId;
        },

        /**
         * 添加助手(AI)消息到历史
         * @returns {string} 消息ID
         */
        addAssistantMessage() {
            const aiMessageId = uuidv4();
            state.messageHistory.value.push({
                id: aiMessageId,
                role: 'assistant',
                content: '',
                loading: true,
                timestamp: new Date().toISOString(),
            });
            return aiMessageId;
        },

        /**
         * 取消当前活跃的请求
         */
        cancelActiveRequest() {
            if (state.activeRequest.value) {
                state.activeRequest.value.abort();
                state.activeRequest.value = null;
            }
        },

        /**
         * 更新AI响应消息内容
         * @param {string} messageId 消息ID
         * @param {string} content 新的内容
         * @param {boolean} isError 是否为错误消息
         */
        updateAssistantMessage(messageId, content, isError = false) {
            const messageIndex = state.messageHistory.value.findIndex(msg => msg.id === messageId);
            if (messageIndex !== -1) {
                const updatedMessage = {
                    ...state.messageHistory.value[messageIndex],
                    content: content,
                    loading: false,
                    error: isError
                };

                state.messageHistory.value.splice(messageIndex, 1, updatedMessage);
                sessionManager.saveCurrentSessionMessages();
            }
        },

        /**
         * 标记所有加载中的消息为已取消
         */
        markLoadingMessagesAsCancelled() {
            state.messageHistory.value.forEach(msg => {
                if (msg.loading) {
                    msg.loading = false;
                    msg.cancelled = true;
                    if (msg.content === '') {
                        msg.content = '[请求已取消]';
                    }
                }
            });
        },

        /**
         * 取消流式请求
         */
        cancelStreamRequest() {
            this.cancelActiveRequest();
            this.markLoadingMessagesAsCancelled();
            state.loading.value = false;
            sessionManager.saveCurrentSessionMessages();
        },

        /**
         * 使用流式API发送用户消息
         * @param {string} message 用户消息内容
         */
        async sendUserMessageStream(message) {
            if (!message.trim()) return;

            // 设置加载状态
            state.loading.value = true;

            // 添加用户消息和AI响应占位消息
            const userMessageId = this.addUserMessage(message);
            const aiMessageId = this.addAssistantMessage();

            // 确保消息角色正确
            this.ensureMessageRoles();

            // 发送API请求
            let responseBuffer = '';

            state.activeRequest.value = sendChatMessageStream(
                {
                    modelId: 'deepseek-chat',
                    chatId: state.currentChatId.value,
                    userPrompt: message,
                },
                // 流式数据处理回调
                (data) => this.handleStreamData(data, aiMessageId, responseBuffer),
                // 错误处理回调
                (error) => this.handleApiError(error, aiMessageId),
                // 完成处理回调
                () => this.handleRequestCompletion()
            );
        },

        /**
         * 处理流式数据
         * @param {string} data 接收到的数据
         * @param {string} messageId 消息ID
         * @param {string} buffer 响应缓冲区
         */
        handleStreamData(data, messageId, buffer) {
            if (!data) return;

            console.log('----收到响应数据:', data);

            // 更新响应缓冲区
            buffer = data;

            // 更新AI响应消息
            this.updateAssistantMessage(messageId, buffer);
        },

        /**
         * 处理API错误
         * @param {Error} error 错误对象
         * @param {string} messageId 消息ID
         */
        handleApiError(error, messageId) {
            console.error('API请求错误:', error);

            this.updateAssistantMessage(
                messageId,
                '抱歉，请求发生错误，请稍后再试。',
                true
            );

            state.loading.value = false;
            state.activeRequest.value = null;
            sessionManager.saveCurrentSessionMessages();
        },

        /**
         * 处理请求完成
         */
        handleRequestCompletion() {
            state.loading.value = false;
            state.activeRequest.value = null;
            sessionManager.saveCurrentSessionMessages();
            sessionManager.updateSessionTitle();
            persistence.saveToStorage();
        }
    };

    // 初始化store
    sessionManager.initStore();

    // 暴露API
    return {
        // 状态
        messageHistory: state.messageHistory,
        loading: state.loading,
        currentChatId: state.currentChatId,
        chatSessions: state.chatSessions,

        // 会话管理方法
        createNewChatSession: sessionManager.createNewChatSession.bind(sessionManager),
        switchChatSession: sessionManager.switchChatSession.bind(sessionManager),
        deleteChatSession: sessionManager.deleteChatSession.bind(sessionManager),
        clearHistory: sessionManager.clearHistory.bind(sessionManager),

        // 消息处理方法
        sendUserMessageStream: messageHandler.sendUserMessageStream.bind(messageHandler),
        cancelStreamRequest: messageHandler.cancelStreamRequest.bind(messageHandler),

        // 持久化方法
        saveSessionsData: persistence.saveToStorage.bind(persistence),
    };
}); 